package com.xuecheng.content.service.impl;

import com.alibaba.cloud.commons.lang.StringUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.api.content.model.CourseBaseDTO;
import com.xuecheng.api.content.model.qo.QueryCourseModel;
import com.xuecheng.common.domain.code.CommonErrorCode;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.common.enums.common.CommonEnum;
import com.xuecheng.common.enums.content.CourseAuditEnum;
import com.xuecheng.common.enums.content.CourseChargeEnum;
import com.xuecheng.common.exception.ExceptionCast;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.common.constant.ContentErrorCode;
import com.xuecheng.content.controller.CourseAuditController;
import com.xuecheng.content.convert.CourseBaseConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.entity.CourseMarket;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.service.CourseBaseService;
import com.xuecheng.content.service.CourseMarketService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 课程基本信息 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service("courseBaseService")
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {

//    @Override
//    public List<CourseBase> queryAll() {
//        return this.list();
//    }

    @Autowired
    private CourseMarketService curseMarketService;

    //*條件查詢
     /*構建mp分頁對象
     /*構建查詢條件
      *查詢數據
      *封裝結果
      *返回數據
      **/
    @Override
    public PageVO<CourseBaseDTO> queryCourseList(PageRequestParams params, QueryCourseModel model, Long companyId) {
        //判斷分頁數據是否合法
        if (params.getPageNo() < 1) {
            params.setPageNo(PageRequestParams.DEFAULT_PAGE_NUM);
        }

        //判斷分頁條件---每頁條數是否合法
        if (params.getPageSize() < 1) {
            params.setPageSize(PageRequestParams.DEFAULT_PAGE_SIZE);
        }

        //構建查詢對象
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();

        //查詢--如果課程的審核狀態不爲空.則其根據課程狀態精確匹配查詢
        queryWrapper.eq(StringUtil.isNotBlank(model.getAuditStatus()),
                CourseBase::getAuditStatus, model.getAuditStatus());

        //查詢,如果課程的名字不為空.則其模糊查詢跟其所有相關的數據
        queryWrapper.like(StringUtils.isNotBlank(model.getCourseName()),
                CourseBase::getName, model.getCourseName());
        queryWrapper.eq(CourseBase::getStatus, CommonEnum.USING_FLAG.getCodeInt());

        if (!(ObjectUtils.nullSafeEquals(companyId, CourseAuditController.COMPAIND))) {
            queryWrapper.eq(CourseBase::getCompanyId, companyId);
        }

        //創建分頁查詢對象
        Page<CourseBase> courseBasePage = new Page<>(params.getPageNo(), params.getPageSize());

        //根據查詢對象和分頁開始查詢
        Page<CourseBase> page = this.page(courseBasePage, queryWrapper);

        //獲取這一頁的數據
        List<CourseBase> records = page.getRecords();
        //将这一页的数据通过MapStruct工具转换为List<CourseBaseDTO>
        List<CourseBaseDTO> courseBaseDTO = new ArrayList<>();
        if (!CollectionUtils.isEmpty(records)) {
            courseBaseDTO = CourseBaseConvert.INSTANCE.entitys2dtos(records);
        }
        //獲取總條數
        long total = page.getTotal();

        //將查詢條件封裝到pageVO中
        //  PageVO(List<T> items, long counts, long page, long pageSize) {
        PageVO courseBases =
                new PageVO<>(courseBaseDTO, total, params.getPageNo(), params.getPageSize());

        //返回數據
        return courseBases;
    }


    /*******  业务分析
     *  1:是否开启事务
     *      增删改都需要开启事务.查询不需要
     *  2:判断关键数据
     *      有此数据才可以继续操作,由前端传送过来
     *        判断依据:数据库表非空等或是前端页面的表单说明
     *  3:判断业务数据
     *       数据库查询过后.如果数据有问题,当前操作终止
     * 4.判断数据是否要被赋值（默认值）
     * status：数据库已经赋值，无需操作
     *           审核状态 auditStatus：新添加的课程默认审核状态--未提交（状态码）
     * 5.将dto转为po数据
     *     因为mp的api只能对po数据进行操作
     * 6.保存数据并返回结果，判断结果是否成功
     * 7.如果操作成功，将数据转为dto并返回
     **/
    @Transactional
    @Override
    public CourseBaseDTO insertCouerseOne(CourseBaseDTO courseBaseDTO) {
//        2:判断关键数据
        if (StringUtils.isEmpty(courseBaseDTO.getCharge())) {
//            throw new RuntimeException("课程的收费规则不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120018);

        }
        if (ObjectUtils.isEmpty(courseBaseDTO.getCompanyId())) {
//            throw new RuntimeException("教育机构不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120019);
        }
        if (StringUtils.isEmpty(courseBaseDTO.getName())) {
//            throw new RuntimeException("课程的名字不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120004);
        }
        if (StringUtils.isEmpty(courseBaseDTO.getMt())) {
//            throw new RuntimeException("课程大的分类不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120002);
        }
        if (StringUtils.isEmpty(courseBaseDTO.getSt())) {
//            throw new RuntimeException("课程的小分类不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120003);
        }
        if (StringUtils.isEmpty(courseBaseDTO.getGrade())) {
//            throw new RuntimeException("课程等级不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120007);
        }
        if (StringUtils.isEmpty(courseBaseDTO.getTeachmode())) {
//            throw new RuntimeException("课程的教育模式不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120006);
        }
        if (StringUtils.isEmpty(courseBaseDTO.getUsers())) {
//            throw new RuntimeException("课程的适用人群不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120020);
        }

        //如果是收费的课程.价格不能为负数且不为空
//        BigDecimal price = courseBaseDTO.getPrice();
        if (courseBaseDTO.getCharge().equals(CourseChargeEnum.CHARGE_YES.getCode())) {
            if (courseBaseDTO.getPrice() == null) {
//                throw new RuntimeException("收费课程价格不合法");
                ExceptionCast.cast(ContentErrorCode.E_120021);
            }
        }
        //判断免费课程价格是否合法
        if (courseBaseDTO.getCharge().equals(CourseChargeEnum.CHARGE_NO.getCode())) {
            if (courseBaseDTO.getPrice() != null) {
//                throw new RuntimeException("免费的课程价格不合法");
                ExceptionCast.cast(ContentErrorCode.E_120022);
            }
        }


        //判断如果是免费课程.价格设置为0
//        if (courseBaseDTO.getCharge().equals(CourseChargeEnum.CHARGE_NO.getCode())) {
//           courseBaseDTO.setPrice(BigDecimal.valueOf(0));
//     }
//       else if(courseBaseDTO.getCharge().equals(CourseChargeEnum.CHARGE_YES.getCode()) && price.doubleValue()<1){
//            throw new RuntimeException("价格不能为负数");
//        }


        //将其状态设置为1--即使用状态
        courseBaseDTO.setStatus(CommonEnum.USING_FLAG.getCodeInt());
        //将其新增的课程设置为未提交‘
        courseBaseDTO.setAuditStatus(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode());
        //将courseBaseDTO利用工具将其属性全部转换为courseBase类属性
        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(courseBaseDTO);
        //将其新增到course_base表中
        boolean save = this.save(courseBase);
        if (!save) {
//            throw new RuntimeException("新增course_base表数据失败");
            ExceptionCast.cast(ContentErrorCode.E_120023);
        }


        //将部分数据封装到CourseMarket中
        CourseMarket courseMarket = new CourseMarket();
        courseMarket.setCourseId(courseBase.getId());
        courseMarket.setCharge(courseBaseDTO.getCharge());
        if (!ObjectUtils.isEmpty(courseBaseDTO.getPrice())) {
            courseMarket.setPrice(courseBaseDTO.getPrice().floatValue());
        }
        boolean save1 = curseMarketService.save(courseMarket);
        if (!save1) {
//            throw new RuntimeException("course_market表数据添加失败");
            ExceptionCast.cast(ContentErrorCode.E_120024);
        }


        LambdaQueryWrapper<CourseBase> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CourseBase::getId, courseBase.getId());
        CourseBase one = this.getOne(wrapper);
        CourseBaseDTO courseBaseDTO1 = CourseBaseConvert.INSTANCE.entity2dto(one);
        if (courseBaseDTO.getCharge().equals(CourseChargeEnum.CHARGE_YES.getCode())) {
            courseBaseDTO1.setPrice(BigDecimal.valueOf(courseMarket.getPrice()));
        }
        courseBaseDTO1.setCharge(courseBaseDTO1.getCharge());
        return courseBaseDTO1;
    }

    /**
     * @param courseBaseId
     * @param companyId
     * @return com.xuecheng.api.content.model.CourseBaseDTO  封装的类
     * @Description //根据课程id查询课程的信息
     * @Date 2021/12/9 23:39
     * @Param [courseBaseId, companyId] courseBaseId为课程的id 。companyId为教育机构的id
     */

    /*    业务分析
     * 1:是否开启事务
     *     查询不开启事务
     * 2:关键数据
     *     courseBaseId为课程id.必须值
     *     companyId为教务机构id 防止查询到别的机构的课程
     * 4:业务数据
     *    判断课程是否删除
     *     判断是否是同一家教育机构
     *     判断是否存在
     * 5:查询封装为DTO返回所有的数据
     *
     **/
    @Override
    public CourseBaseDTO qyeryCourseById(Long courseBaseId, Long companyId) {
        //关键数据判断
        if (ObjectUtils.isEmpty(companyId)) {
//            throw new RuntimeException("未传入教育机构id");
            ExceptionCast.cast(ContentErrorCode.E_120025);
        }
        if (ObjectUtils.isEmpty(courseBaseId)) {
//            throw new RuntimeException("未传入课程的id");
            ExceptionCast.cast(ContentErrorCode.E_120026);

        }
        //根据课程id与教育机构在course_base课程信息表查询
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId)
                .eq(CourseBase::getCompanyId, companyId);
        CourseBase result = this.getOne(queryWrapper);
        if (ObjectUtils.isEmpty(result)) {
//            throw new RuntimeException("课程不存在");
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }
        if (result.getStatus().equals(CommonEnum.DELETE_FLAG.getCode())) {
//            throw new RuntimeException("课程已经被删除了,查不到信息了");
            ExceptionCast.cast(ContentErrorCode.E_120027);
        }
        //根据课程的id在course_market查询其营销数据
        LambdaQueryWrapper<CourseMarket> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CourseMarket::getCourseId, courseBaseId);
        CourseMarket market = curseMarketService.getOne(wrapper);
        //判断查询后的数据否为空
        if (ObjectUtils.isEmpty(market)) {
//            throw new RuntimeException("课程营销的数据不存在");
            ExceptionCast.cast(ContentErrorCode.E_120101);
        }
        //使用工具类将result转成DTO形式的
        CourseBaseDTO courseBaseDTO = CourseBaseConvert.INSTANCE.entity2dto(result);
        //将查询到的营销数据封装到DTO中
        courseBaseDTO.setCharge(market.getCharge());
        if (!(ObjectUtils.isEmpty(courseBaseDTO.getPrice()))) {
            courseBaseDTO.setPrice(new BigDecimal(market.getPrice()));
        }
        return courseBaseDTO;
    }


    /**
     * 业务分析:
     * 是否需要事务开启
     * 增删改都要用到事务
     * 关键数据
     * dto中依照API或者数据库判断是否合法
     * 业务数据
     * 哪些数据前台没法传输,需要我们自己设置的
     * 查询
     * 是否有id为DTO_id的课程
     * 是否有id为DTO_id的营销数据
     * 数据是否删除(start为0即逻辑删除了)
     * 课城转态是否为‘未提交’、‘审核未通过
     * 查询接果
     * 是否有数据
     * 结果封装
     * po数据为了数据库字段安全和效率转换为DTO形式
     * 结果返回
     */
    @Override
    @Transactional
    public CourseBaseDTO modifyCourseBase(CourseBaseDTO dto) {
//        关键数据
//        *      dto中依照API或者数据库判断是否合法
        if (StringUtils.isEmpty(dto.getCharge())) {
//            throw new RuntimeException("收费规则不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120018);
        }
        if (StringUtils.isEmpty(dto.getGrade())) {
//            throw new RuntimeException("课程等级不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120007);
        }
        if (StringUtils.isEmpty(dto.getMt())) {
//            throw new RuntimeException("课程分类不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120002);
        }
        if (StringUtils.isEmpty(dto.getName())) {
            ExceptionCast.cast(ContentErrorCode.E_120004);
        }
        if (ObjectUtils.isEmpty(dto.getCompanyId())) {
//            throw new RuntimeException("教育机构不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120026);
        }
        if (StringUtils.isEmpty(dto.getSt())) {
            ExceptionCast.cast(ContentErrorCode.E_120003);
        }
        if (StringUtils.isEmpty(dto.getTeachmode())) {
//            throw new RuntimeException("课程的教育模式不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120019);
        }
        if (StringUtils.isEmpty(dto.getUsers())) {
//            throw new RuntimeException("使用人群不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120020);
        }
        if (ObjectUtils.isEmpty(dto.getCourseBaseId())) {
//            throw new RuntimeException("课程的id不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120026);
        }
        //业务数据判断
        //如果课程免费则其价格为null
        //如果课程收费则其价格>=0
        if (dto.getCharge().equals(CourseChargeEnum.CHARGE_YES.getCode())) {
            if (dto.getPrice() == null) {
//                throw new RuntimeException("收费课程价格不合法");
                ExceptionCast.cast(ContentErrorCode.E_120021);
            }
        }
        //判断免费课程价格是否合法
        if (dto.getCharge().equals(CourseChargeEnum.CHARGE_NO.getCode())) {
            if (dto.getPrice() != null) {
//                throw new RuntimeException("免费的课程价格不合法");
                ExceptionCast.cast(ContentErrorCode.E_120022);
            }
        }
        Long companyId = dto.getCompanyId();
        //如果是个人修改的课程--其不能修改自己课程的状态..主键id.机构id.机构名
        dto.setCompanyId(null);
        dto.setAuditStatus(null);
        dto.setStatus(null);

        //将dto数据转换为po
        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(dto);
        //更新course_base表数据
//        boolean b = this.updateById(courseBase);
        //调用方法修改course_base表数据
        //先根据id查询表中数据
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBase.getId());
        CourseBase queryResult = this.getOne(queryWrapper);
        //判断根据id查询的数据是否存在
        if (ObjectUtils.isEmpty(queryResult)) {
//            throw new RuntimeException("当前的课程id有误");
            ExceptionCast.cast(ContentErrorCode.E_120028);
        }
        //当前数据是否已经被逻辑删除了
        if (queryResult.getStatus().equals(0)) {
//            throw new RuntimeException("当前已经被逻辑删除了");
            ExceptionCast.cast(ContentErrorCode.E_120029);
        }
        //当前的状态是否为未提交或者审核未通过
        if (!queryResult.getAuditStatus().equals(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode()) &&
                !queryResult.getAuditStatus().equals(CourseAuditEnum.AUDIT_DISPAST_STATUS.getCode())) {
//            throw new RuntimeException("当前的审核状态不是未提交或审核未通过.不能修改");
            ExceptionCast.cast(ContentErrorCode.E_120014);

        }
        //机构id是否与前端传入的相同
        System.out.println(queryResult.getCompanyId());
        System.out.println(companyId);
        if (!queryResult.getCompanyId().equals(companyId)) {
//            throw new RuntimeException("当前传入的机构id有误");
            ExceptionCast.cast(ContentErrorCode.E_120030);
        }
        //修改course_base数据表
        courseBase.setChangeDate(LocalDateTime.now());
        boolean b = this.updateById(courseBase);
        if (!b) {
//            throw new RuntimeException("未知原因,修改失败");
            ExceptionCast.cast(ContentErrorCode.E_120031);
        }

        //根据课程id查询course_market表数据
        LambdaQueryWrapper<CourseMarket> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CourseMarket::getCourseId, courseBase.getId());
        CourseMarket market = curseMarketService.getOne(wrapper);
        if (ObjectUtils.isEmpty(market)) {
//            throw new RuntimeException("营销数据不存在");
            ExceptionCast.cast(ContentErrorCode.E_120101);
        }
        //将dto中关于营销数据的属性封装到CourseMarket
        CourseMarket courseMarket = new CourseMarket();
        courseMarket.setCourseId(courseBase.getId());
        courseMarket.setCharge(dto.getCharge());
        if (dto.getCharge().equals(CourseChargeEnum.CHARGE_YES.getCode())) {
            courseMarket.setPrice(dto.getPrice().floatValue());
        }
        //根据课程的id修改营销数据表
        LambdaUpdateWrapper<CourseMarket> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(CourseMarket::getCourseId, courseMarket.getCourseId())
                .set(CourseMarket::getCharge, courseMarket.getCharge())
                .set(CourseMarket::getPrice, courseMarket.getPrice());
        boolean update = curseMarketService.update(updateWrapper);
        if (!update) {
//            throw new RuntimeException("未知原因修改course_market表数据失败");
            ExceptionCast.cast(ContentErrorCode.E_120032);
        }
        //查询所有的数据.更新dto数据返回结果集
        LambdaUpdateWrapper<CourseBase> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        lambdaUpdateWrapper.eq(CourseBase::getId, dto.getCourseBaseId());
        CourseBase courseBase1 = this.getOne(lambdaUpdateWrapper);
        if (ObjectUtils.isEmpty(courseBase1)) {
//            throw new RuntimeException("最后查询结果集时未知失败");
            ExceptionCast.cast(ContentErrorCode.E_120033);
        }
        //po数据转为dto
        CourseBaseDTO courseBaseDTO = CourseBaseConvert.INSTANCE.entity2dto(courseBase1);
        courseBaseDTO.setPrice(dto.getPrice());
        courseBaseDTO.setCharge(dto.getCharge());
        return courseBaseDTO;
    }

    /**
     * 根据课程Id进行删除操作
     * courseBaseId  Long 课程的主键id值.
     * companyId  Long 课程所属的教育机构id值
     *
     * @param courseBaseId
     * @param companyId    业务分析
     *                     1:是否开启事务
     *                     增删改都需要添加事务关系
     *                     2:关键数据分析
     *                     courseBaseId主键id必须合法且存在
     *                     companyId 教育机构id必须存在且与课程id查询到的机构id值相同
     *                     3:业务数据
     *                     是是否有次id值对应的课程
     *                     课程是否已经被逻辑删除了
     *                     教育机构id是否与前端传来的一致
     *                     审核状态是否为未提交或是审核未通过
     *                     4:先根据id查询课程 --判断其审核状态与教育机构id
     *                     5:修改课程状态即starts修改为0
     */
    @Override
    @Transactional
    public void removeCourseBase(Long courseBaseId, Long companyId) {
//        2:关键数据分析
        if (ObjectUtils.isEmpty(courseBaseId)) {
//            throw new RuntimeException("课程的id值不能为空");
            ExceptionCast.cast(ContentErrorCode.E_120009);
        }
        if (ObjectUtils.isEmpty(companyId)) {
//            throw new RuntimeException("必须携带教育机构的id值");
            ExceptionCast.cast(ContentErrorCode.E_120025);

        }
        //根据id查询课程
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        CourseBase courseBase = this.getOne(queryWrapper);
        //判断其数据是否支持逻辑删除
        if (ObjectUtils.isEmpty(courseBase)) {
//            throw new RuntimeException("没有此id对应的课程");
            ExceptionCast.cast(ContentErrorCode.E_120034);

        }
        if (!courseBase.getCompanyId().equals(companyId)) {
//            throw new RuntimeException("教育机构出错");
            ExceptionCast.cast(ContentErrorCode.E_120030);

        }
        if (!courseBase.getAuditStatus().equals(CourseAuditEnum.AUDIT_DISPAST_STATUS.getCode()) &&
                !courseBase.getAuditStatus().equals(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode())) {
//            throw new RuntimeException("当前审核状态不支持删除");
            ExceptionCast.cast(ContentErrorCode.E_120012);

        }
        if (courseBase.getStatus().equals(0)) {
//            throw new RuntimeException("当前的课程已经被逻辑删除过");
            ExceptionCast.cast(ContentErrorCode.E_120029);

        }
        //逻辑删除

        LambdaUpdateWrapper<CourseBase> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(CourseBase::getId, courseBaseId).set(CourseBase::getStatus, CommonEnum.DELETE_FLAG.getCodeInt())
                .set(CourseBase::getChangeDate, LocalDateTime.now());
        boolean update = this.update(wrapper);
        if (!update) {
//            throw new RuntimeException("未知原因删除失败");
            ExceptionCast.cast(ContentErrorCode.E_120035);

        }
        System.out.println("修改成功");
        LocalDateTime now = LocalDateTime.now();
        log.info("修改成功,修改的课程id{},修改时间{}", courseBase.getId(), now);
    }

    /**
     * @param courseBaseId
     * @param companyId
     * @return void
     * @Description 提交课程审核
     * @Date 2021/12/13 16:33
     * @Param [courseBaseId, companyId]  课程id和教育机构id
     * <p>
     * 业务分析
     * 关键数据
     * 判断课程id和教育机构id是否为空
     * 业务数据
     * 教育机构id是否正确
     * 课程是否被逻辑删除
     * 课程是否是未提交和审核未通过状态
     * 是否有此课程
     * 开始修改数据库
     * 将其审核状态修改为已提交
     */
    @Override
    public void commitCourseBase(Long courseBaseId, Long companyId) {
        //判断关键数据
        if (ObjectUtils.isEmpty(courseBaseId) || ObjectUtils.isEmpty(companyId)) {
            ExceptionCast.cast(ContentErrorCode.E_120026);
        }
        //根据id查询课程
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        //判断业务数据
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        CourseBase courseBase = this.getOne(queryWrapper);
        //判断业务数据
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }
        if (!(courseBase.getCompanyId().equals(companyId))) {
            ExceptionCast.cast(ContentErrorCode.E_120030);
        }
        if (courseBase.getStatus().equals(CommonEnum.DELETE_FLAG.getCodeInt())) {
            ExceptionCast.cast(ContentErrorCode.E_120029);
        }
        if (!(courseBase.getAuditStatus().equals(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode())) &&
                !(courseBase.getAuditStatus().equals(CourseAuditEnum.AUDIT_DISPAST_STATUS.getCode()))) {
            ExceptionCast.cast(ContentErrorCode.E_120014);
        }

        //将审核状态修改成已提交
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(CourseBase::getId, courseBaseId);
        updateWrapper.set(CourseBase::getAuditStatus, CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());
        boolean update = this.update(updateWrapper);
        if (!update) {
            ExceptionCast.cast(ContentErrorCode.E_120031);
        }
    }

    /**
     * @param dto
     * @return void
     * @Description //运营审核
     * @Date 2021/12/13 18:36
     * @Param [dto]  数据-->课程id,课程审核转态.课程意见
     * ；业务分析
     * 关键数据
     * 课程id 状态.意见都不能为空
     * 业务数据
     * 判断是否有此课程
     * 是否为已提交
     * 是否已删除
     */
    @Override
    public void approveCourse(CourseBaseDTO dto) {
        //判断关键数据
        if (StringUtil.isBlank(dto.getAuditMind()) ||
                StringUtil.isBlank(dto.getAuditStatus()) ||
                ObjectUtils.isEmpty(dto.getCourseBaseId())
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }
        //根据课程id查询
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, dto.getCourseBaseId());
        CourseBase queryOne = this.getOne(queryWrapper);
        if (ObjectUtils.isEmpty(queryOne)) {
            ExceptionCast.cast(CommonErrorCode.E_100104);
        }
        if (queryOne.getStatus().equals(CommonEnum.DELETE_FLAG)) {
            ExceptionCast.cast(ContentErrorCode.E_120029);
        }
        if (!(queryOne.getAuditStatus().equals(CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode()))) {
            ExceptionCast.cast(ContentErrorCode.E_120015);
        }
        //判断其核心数据是否为审核通过或者审核未通过
        if (!(dto.getAuditStatus().equals(CourseAuditEnum.AUDIT_DISPAST_STATUS.getCode()))
                && !(dto.getAuditStatus().equals(CourseAuditEnum.AUDIT_PASTED_STATUS.getCode()))) {
            ExceptionCast.cast(ContentErrorCode.E_120015);
        }
        //获取审核次数
        Integer auditNums = queryOne.getAuditNums();
        //开始修改课程信息
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(CourseBase::getId, dto.getCourseBaseId());
        updateWrapper.set(CourseBase::getAuditStatus, dto.getAuditStatus());
        updateWrapper.set(CourseBase::getAuditNums, auditNums + 1);
        updateWrapper.set(CourseBase::getAuditMind, dto.getAuditMind());
        //修改时mp会使最新时间自动填充失败.所以重新赋值
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());
        boolean update = this.update(updateWrapper);
        if (!update) {
            ExceptionCast.cast(ContentErrorCode.E_120017);
        }


    }
}

